<%
/**
* 描述：输出json或array便于理解的信息。
* @param  json|array $value 
* @param  string     $crlf  换行符
* @return void
*/
/*
function print_r($value,$crlf)
{
	var callCount=1;
	
	if($value!=undefined&&($value.constructor==Array||$value.constructor==Object)){
		if($value.constructor==Array){
			Response.Write('Array\n');
			Response.Write('(\n');
			for(var i=0;i<$value.length;i++){
				if($value[i].constructor==Array||$value[i].constructor==Object){
					if($value[i].constructor==Array){
						__array($value[i],i);
					}
					else{
						__json($value);
					}					
				}
				else{
					if(i==$value.length-1)
						Response.Write('\t['+i+']=>'+$value[i]+'\n');
					else
						Response.Write('\t['+i+']=>'+$value[i]+',\n');
				}
			}
			Response.Write(');');			
		}
		else{
			//JSON
		}
			
		function __array(_value,_index)
		{
			var tabValue=Array.prototype.join.call({length:callCount+1},'\t');
			Response.Write(tabValue+'['+_index+']=>Array\n');
			Response.Write(tabValue+'(\n');
			for(var j=0;j<_value.length;j++){
				if(_value[j].constructor==Array||_value[j].constructor==Object){
					callCount++;
					__array(_value[j],j);
				}
				else{
					if(j==_value.length-1)					
						Response.Write(tabValue+'\t['+j+']=>'+_value[j]+'\n');
					else
						Response.Write(tabValue+'\t['+j+']=>'+_value[j]+',\n');
				}
			}
			Response.Write(tabValue+'),\n');
		}
		
		function __json()
		{
			
		}			
	}
	else{
		Response.Write($value);
	}	
}
///<summary>
///获取页面请求方法
///</summary>		
function httpType()
{
	return Request.ServerVariables("REQUEST_METHOD");
}

///<summary>
///获取脚本文件名称带路径的
///</summary>		
function scriptFileName()
{
	return Request.ServerVariables("SCRIPT_NAME");
}
*/







///<summary>
///格式化日期对象或字符串
///</summary>		
function formatDate($date)
{
	$date=(typeof $date=='date' ? $date=new Date($date):$date);
	return $date.getYear()+'-'+($date.getMonth()+1)+'-'+$date.getDate()+' '+$date.getHours()+':'+$date.getMinutes()+':'+$date.getSeconds(); 
}


///<summary>
///转向页面
///</summary>		
function goPath(path)
{
	Response.Redirect(path);
}

///<summary>
///中断并输出错误带格式
///</summary>		
function printASPError($title,$err)
{
	Response.Write("<span style='font-size:20px;color:red;'>"+$title+"</span><hr/><span>"+$err+"</span>");
	Response.End();
}
	
	///<summary>
	///页面类基类
	///</summary>
	System.Page=function(){};
	{
		System.Page.prototype=
		{
			importLabels:function(json)
			{
				if(!('template' in this))
					printASPError(scriptFileName()+' 执行importLabels方法为模板绑定数据时发生错误','在本页面类中找不到名为 template 的属性。请先声明 template 属性，并且为其赋值一个Template类的实例。<br/>可以在类中这样声明：this.template=new System.Template(参数);(Template类的实例);。');
				
				for(var ip in json)
				{
					this.template.labels[ip]={};
					this.template.labels[ip].name=ip;			
					this.template.labels[ip].value=json[ip].value;
				}
			},		
			setLabel:function(name,value)
			{
				if(!('template' in this))
					printASPError(scriptFileName()+' 执行setLabel方法为模板绑定数据时发生错误','不能为名为 '+name+' 的标签赋值，因为在本页面类中找不到名为 template 的属性。请先声明 template 属性，并且为其赋值一个Template类的实例。<br/>可以在类中这样声明：this.template=new System.Template(参数);(Template类的实例);。');
				if(!(name in this.template.labels))
					printASPError(scriptFileName()+' 执行setLabel方法为模板绑定数据时发生错误','找不到属性：'+name+'，模板中并没有定义'+name+'标签,请仔细检查。');
					
				this.template.labels[name].value=value;
			},		
			getLabel:function(name)
			{
				if(!('template' in this))
					printASPError(scriptFileName()+' 执行getLabel方法为模板绑定数据时发生错误','不能为名为 '+name+' 的标签赋值，因为在本页面类中找不到名为 template 的属性。请先声明 template 属性，并且为其赋值一个Template类的实例。<br/>可以在类中这样声明：this.template=new System.Template(参数);(Template类的实例);。');
				
				if(!(name in this.template.labels))
					printASPError(scriptFileName()+' 执行getLabel方法为模板绑定数据时发生错误','找不到属性：'+name+'，模板中并没有定义'+name+'标签,请仔细检查。');
					
				return this.template.labels[name].value;
			},		
			getRepeater:function(name)
			{
				if(!('template' in this))
					printASPError(scriptFileName()+' 执行getRepeater方法获取Repeater对象时发生错误','不能获取Id为'+name+'的Repeater对象，因为在本页面类中找不到名为 template 的属性。请先声明 template 属性，并且为其赋值一个Template类的实例。<br/>可以在类中这样声明：this.template=new System.Template(参数);(Template类的实例);。');
									
				if(!(name.toLowerCase() in this.template.repeaters)){
					printASPError(scriptFileName()+' 执行getRepeater方法获取Repeater对象时发生错误','找不到对象：'+name+'，模板中并没有定义id为'+name+'的Repeater控件,请仔细检查。');
				}
				 return this.template.repeaters[name.toLowerCase()];
			}			
		}
	};	
	
	///<summary>
	///创建类的函数
	///</summary>
	function Class()
	{
		///直接返回类并调用构造函数
		if(arguments.length==0)
		{
			return function()
			{
				try
				{
					this.initialize.apply(this,arguments)
				}
				catch(e)
				{}
			}
		}
		
		///开始生成类
		var iniFunc=function(){};
		var iniPrototype={};
		var isPageClass=false;
		var classNameRegexp=/^[a-zA-z_\$][a-zA-z0-9_]*$/;
		var classNameRegexp_json1=/^[a-zA-z_\$][a-zA-z0-9_]*\.[a-zA-z_\$][a-zA-z0-9_]*$/;
		var className='';
		
		///遍历参数
		for(var ipro=0;ipro<arguments.length;ipro++)
		{
			//创建选项
			if(typeof(arguments[ipro])=='object')
			{
				if(ipro!=0) printASPError(scriptFileName()+' 创建类时发生错误','类创建选项必须是唯一JSON对象且只能是第一个参数。该JSON对象是第'+(ipro+1)+'个参数。');
				
				for(var iOptions in arguments[ipro])
				{
					if(iOptions!='name'&&iOptions!='extend')
						printASPError(scriptFileName()+' 创建类时发生错误','无该创建选项，请指定正确的创建选项name或extend。当前选项名称：'+iOptions);
				}
								
				if('name' in arguments[ipro])
				{
					className=arguments[ipro].name;
					
					if(typeof(className)!='string')
						printASPError(scriptFileName()+' 创建类时发生错误','指定的类名称只能是字符串类型。');
					else
					{
						if(className=='')
							printASPError(scriptFileName()+' 创建类时发生错误','类名称为空，请给类命名。');
						else
						{	
							if(!classNameRegexp.test(className)&&!classNameRegexp_json1.test(className)) 
								printASPError(scriptFileName()+' 创建类时发生错误','类名称非法，请使用正确的标识符。当前类名为：'+className);	
							if(Const.Keywords.toString().indexOf(className)!=-1)
								printASPError(scriptFileName()+' 创建类时发生错误','类名称非法，该名称是系统保留字.请使用正确的标识符。当前类名为：'+className);	
						}
					}
				}				
				
				if('extend' in arguments[ipro])
				{
					if(typeof(arguments[ipro].extend)!='function')
						printASPError(scriptFileName()+' 创建类时发生错误','要继承的父类并不是一个正确的类。');					
					
					if(arguments[ipro].extend==System.Page) isPageClass=true;				
				}				
			}
			//创建类的方法
			else if(typeof(arguments[ipro])=='function')
			{
				var funcName=arguments[ipro].toString().match(/^function\s+([\w\$]+)/g);
				{
					funcName=funcName.toString().split(' ')[1];
					funcName=funcName.replace(/\s/g,'');
					
					//处理参数分配到相应位置	
					if(funcName=='initialize')
					{
						iniFunc=arguments[ipro];
					}
					else
						iniPrototype[funcName]=arguments[ipro];					
				};			
			}
			else
			{
				printASPError(scriptFileName()+' 创建类时发生错误','参数类型不匹配，只能是JSON对象和function类型。当前参数类型是：'+(typeof arguments[ipro]));				
			}
		}
		
		///继承处理
		if(arguments[0].extend!=null)
		{
			iniPrototype['bassClass']={};
			
			for(var proName in arguments[0].extend.prototype)
			{
				if(proName=='initialize')		
					iniPrototype['bassClass']['initialize']=arguments[0].extend.prototype[proName];		//父类构造函数 兼容赋值式的创建类
				else
					iniPrototype[proName]=arguments[0].extend.prototype[proName];
			}
			
			if(!('initialize' in iniPrototype['bassClass']))
				iniPrototype['bassClass']['initialize']=arguments[0].extend;							//父类构造函数 兼容function和Class式创建类
		}

		///创建类		
		iniFunc.prototype=iniPrototype;

		///页面类处理
		if(isPageClass==true)	
		{
			if(!('page_load' in iniPrototype)) 
				printASPError(scriptFileName()+' 创建类时发生错误','该类是页面类，但没有提供页面类入口函数page_load。当前类名：'+className);
			
			iniFunc=iniPrototype['page_load'];
			{
				delete iniPrototype['page_load'];
				iniFunc.prototype=iniPrototype;
			};
			
			var tempPageClass=new iniFunc();
			{
				if('page_unload' in tempPageClass) tempPageClass.page_unload();
				tempPageClass=null;
			};
			return null;
		}
		///普通类 不返回
		else if(className!='')	
		{
			eval(className+'=iniFunc');
		}
		///普通类 返回
		else
		{
			return iniFunc;
		}
	}	
	
	///<summary>
	///抛错函数
	///</summary>
	function throwError()
	{
		if(arguments.length==1)
			throw {number:Const.CustomError,description:arguments[0]};
		else if(arguments.length==2)
			throw {number:arguments[0],description:arguments[1]};			
		else 
			printASPError(scriptFileName()+' throwError 函数错误','提供的参数数目与函数定义的参数数目不符，您提供了'+arguments.length+'个参数，请提供一到两个参数。<br/>提示：提供一个参数时抛出的错误类型是属于"自定义错误"，参数信息是您所提供的这个参数。提供两个参数时，第一个参数是错误类型，第二个是参数错误描述。');			
	}	
	
	
	///<summary>
	///抛错函数
	///</summary>	
	function processPagecode(pageCode,pageCount)
	{		
		//无效值
		if(pageCode==''||pageCode==null) return 1;
		if(isNaN(pageCode)) return 1;
		//大小验证		
		pageCode=parseInt(pageCode);
		pageCount=parseInt(pageCount);
		if(pageCode<1) return 1;
		if(pageCode>pageCount) return pageCount;
		//直接输出
		return pageCode;
	}
	
	///<summary>
	///分页函数
	///</summary>		
	function displayPagemenuStyle1(recordsetObject,parameters,isDetails,curtomTags)
	{
		var tags=curtomTags||{pre:'上一页',next:'下一页',first:'第一页',last:'最后一页',details:'共pageCount页 当前第pageCode页'};	//转到第toPagecode页
		var isShowDetails=(isDetails==null ? true:isDetails);
		
		if((recordsetObject.eof&&recordsetObject.bof)||recordsetObject.PageCount<=1)
			return '';
		else
		{
			var tempStr='';
			
			var pageCode=processPagecode(Request.QueryString('page'),recordsetObject.PageCount);
			if(pageCode<=0) pageCode=1;
				
			var params='';
			if(parameters!=null) params=parseJsonToQuerystring(parameters);
			params=(params=='' ? '':'&'+params);
			
			if(pageCode==1)
				tempStr='<span style="color:gray;">'+tags.first+'</span> <span style="color:gray;">'+tags.pre+'</span> <a href="?page='+(pageCode+1)+params+'">'+tags.next+'</a> <a href="?page='+recordsetObject.PageCount+params+'">'+tags.last+'</a> ';
			else if(pageCode==recordsetObject.PageCount)
				tempStr='<a href="?page=1'+params+'">'+tags.first+'</a> <a href="?page='+(pageCode-1)+params+'">'+tags.pre+'</a> <span style="color:gray;">'+tags.next+'</span> <span style="color:gray;">'+tags.last+'</span> ';
			else
				tempStr='<a href="?page=1'+params+'">'+tags.first+'</a> <a href="?page='+(pageCode-1)+params+'">'+tags.pre+'</a> <a href="?page='+(pageCode+1)+params+'">'+tags.next+'</a> <a href="?page='+recordsetObject.PageCount+params+'">'+tags.last+'</a> ';
			
					
			if(isShowDetails==true)
			{
				var htmlSelectControl='<select onchange="window.location=\'?page=\'+this.value+\''+params+'\'">';
				for(var iPage=1;iPage<=recordsetObject.PageCount;iPage++){
					htmlSelectControl+='<option value="'+iPage+'" '+(pageCode==iPage ? 'selected="selected"':'')+'>'+iPage+'</option>';
				}
				htmlSelectControl+='</select>';
				tempStr+=' ';
				tempStr+=tags.details;
				tempStr=tempStr.replace(/pageCode/,pageCode);
				tempStr=tempStr.replace(/pageCount/,recordsetObject.PageCount);
				tempStr=tempStr.replace(/toPagecode/,htmlSelectControl);
			}
			return tempStr;
			//阿门
		}
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	

	








	
	///<summary>
	///解析JSON对象到URL参数字符串
	///</summary>		
	function parseJsonToQuerystring(json)
	{
		var tempStr='';
		for(var per in json){
			tempStr+=(per+'='+json[per]+'&');
		}
		tempStr=tempStr.substring(0,tempStr.length-1);
		return tempStr;
	}
	

	
	///<summary>
	///获取日期时间与随机数组成的字符串
	///</summary>	
	function datetimeCombinactions()	
	{
		var tempStr='';
		var dateObject=new Date();
			tempStr=dateObject.getYear().toString();
			tempStr+=(dateObject.getMonth()+1).toString();
			tempStr+=dateObject.getDate().toString();
			//tempStr+=dateObject.getHours().toString();
			//tempStr+=dateObject.getMinutes().toString();
			//tempStr+=dateObject.getSeconds().toString();
			//tempStr+=dateObject.getMilliseconds().toString()+parseInt(Math.random()*9);			
			dateObject=null;
		return tempStr;
	}
	

	///<summary>
	///将字符串转换成字节
	///</summary>
	function stringToBytes(str)
	{
		var bytes=[];
		for(var iBytes=0;iBytes<str.length;iBytes++){
			var singleStr=str.charCodeAt(iBytes);
				bytes.push(singleStr >> 8);						//右移8位获得高字节
				bytes.push(singleStr & 0xFF);					//逻辑与0xFF获得低字节
		}
		return bytes;
	}
	
	///<summary>
	///截取字符串
	///</summary>	
	function cutStr(str,length,method)
	{		
		var result='';
		if(isNaN(length)||length==0) return '';
		if(str==null||str=='') return '';
		
		result=str.substr(0,length);
		
		var trueLength=0;
		for(var i=0;i<result.length;i++){
			if(/^[\u4e00-\u9fa5]{0,}$/.test(str.charAt(i))==false){
				trueLength+=2;
			}else{
				trueLength+=1;
			}
		}
		if(trueLength>length) result=str.substr(0,trueLength);
		length=trueLength;
		if(str.length>length) result+='..';
		return result;
	} 		
	
	///<summary>
	///去字符串除两边的空格
	///</summary>	
	function trim(str)
	{
		return str.replace(/^\s+/,'').replace(/\s+$/,'');
	}	
	
	///<summary>
	///智能的返回正则表达式的结果
	///</summary>	
	function regexpMatchValue(regexpResult,index)
	{
		return regexpResult==null ? null:regexpResult[index];
	}	
	

	
	///<summary>
	///模板对象
	///</summary>		
	System.Template=new Class();
	{
		System.Template.prototype=
		{
			initialize:function()
			{
				if(arguments.length==0) printASPError(scriptFileName()+' 实例化Template对象出错','请为Template对象提供模板。');
				
				var dataObject={};
				if(typeof arguments[0]=='string'&&arguments.length==1)
					dataObject=this.private.getDataobject.apply(this,arguments);
				else if(typeof arguments[0]=='object'&&arguments.length>=2)
					dataObject=this.private.getDataobject.apply(this,[this.private.makeTemplate.apply(this,arguments)]);
				else
					printASPError(scriptFileName()+' 实例化Template对象出错','参数发生错误，提供的参数不符合实例化Template对象的要求。');
				
				this.mainTemplate=dataObject.mainTemplate;
				this.labels=dataObject.labels;
				this.repeaters=dataObject.repeaters;
				this.labelsCount=dataObject.labelsCount;
				this.repeatersCount=dataObject.repeatersCount;
				
				dataObject=null;
			},
			
			bind:function(isPrint) 
			{
				//渲染标签
				this.private.labelsTobindMainTemplate.apply(this,[this.labels]);
				
				//渲染Repeater
				for(var repeaterName in this.repeaters)
				{
					if(this.repeaters[repeaterName].template.item==null) 
						printASPError(scriptFileName()+' 渲染模板Repeater控件出错。Repeater名称：'+repeaterName,'您必须为Repeater控件提供<ItemTemplate></ItemTemplate>子模板。');					
					
					var repeater=this.repeaters[repeaterName];				
						
					//渲染itemTemplate																								
					var itemText=this.private.getItemText.apply(this,[repeater]);
					
					var headerText=this.private.getHeaderText.apply(this,[repeater]);
					
					var footerText=this.private.getFooterText.apply(this,[repeater]);
	
					//完成Repeater渲染，印刷至主模板
					this.private.repeaterTobindMianTemplate.apply(this,[repeater,itemText,headerText,footerText]);
				}
				
				//处理结果
				if(isPrint==true) print(this.mainTemplate);
				return this.mainTemplate;
			},
			
			finalize:function()
			{
				this.dataObject=null;
				this.mainTemplate=null;
				this.labels=null;
				this.repeaters=null;
			},
			
			private:
			{
				makeTemplate:function()
				{			
					if(arguments.length==2)
					{
						if(typeof arguments[1]!='string'){
							printASPError(scriptFileName()+' 实例化Template对象出错','参数错误，最后一个母版页必须是有效的字符串。');
						}
						var tempRegexp=new RegExp('<asp:ContentPlaceHolder\\s+id="'+(arguments[0].contentId)+'"[^>]*\\s*?\/\>','ig');
						return arguments[1].replace(tempRegexp,arguments[0].template);
					}
					else
					{
	
						if(typeof arguments[1]!='object'){
							printASPError(scriptFileName()+' 实例化Template对象出错','参数错误，使用多个嵌套母板时您必须提供有效的母板页对象。发生错误的是第2个参数。');
						}					
															
						var template='';
						var tempRegexp=new RegExp('<asp:ContentPlaceHolder\\s+id="'+(arguments[0].contentId)+'"[^>]*\\s*?\/\>','ig');
							template={
								contentId:arguments[1].contentId,
								template:arguments[1].template.replace(tempRegexp,arguments[0].template)
							};
							
							for(var it=2;it<arguments.length;it++)
							{
								if(it==arguments.length-1)	//最后一个
								{
									
									if(typeof arguments[it]!='string')
										printASPError(scriptFileName()+' 实例化Template对象出错','参数错误，您提供的最后一个母版页必须是有效的字符串。');
									
									tempRegexp=new RegExp('<asp:ContentPlaceHolder\\s+id="'+(template.contentId)+'"[^>]*\\s*?\/\>','ig');								
									template=arguments[it].replace(tempRegexp,template.template);								
								}
								else
								{
									if(typeof arguments[it]!='object')
										printASPError(scriptFileName()+' 实例化Template对象出错','参数错误，您提供了多个母板页，但提供的第'+(it+1)+'个母板，并不是所要求的母板页对象。');
										
									tempRegexp=new RegExp('<asp:ContentPlaceHolder\\s+id="'+(template.contentId)+'"[^>]*\\s*?\/\>','ig');
									template={
										contentId:arguments[it].contentId,
										template:arguments[it].template.replace(tempRegexp,template.template)
									}
									
								}
							}						
							return template;
					}	
				},
				
				labelsTobindMainTemplate:function(labels)
				{
					for(var labelName in labels)
					{
						var re=new RegExp('<%=\\s*?'+labelName+'\\s*?%\\>','ig');
						this.mainTemplate=this.mainTemplate.replace(re,this.labels[labelName].value);
					}					
				},
								
				repeaterTobindMianTemplate:function(repeaterObject,itemText,headerText,footerText)
				{
					var repeaterText=repeaterObject.template.main.replace(/<itemTemplate[^>]*\>[\s\S]*?<\/itemTemplate\>/i,itemText);
						repeaterText=repeaterText.replace(/<headerTemplate[^>]*\>[\s\S]*?<\/headerTemplate\>/i,headerText);
						repeaterText=repeaterText.replace(/<footerTemplate[^>]*\>[\s\S]*?<\/footerTemplate\>/i,footerText);
						repeaterText=repeaterText.replace(/<asp:Repeater[^>]*\>/ig,'');	
						repeaterText=repeaterText.replace(/<\/asp:Repeater[^>]*\>/ig,'');	
						//repeaterText=trim(repeaterText);					
						
					var re=new RegExp('<asp:Repeater\\s+id="\\s*?'+repeaterObject.id+'\\s*?"[^>]*\>[\\s\\S]*?<\\/asp:Repeater\\>','ig');					
					this.mainTemplate=this.mainTemplate.replace(re,repeaterText);
				},
				
				getRowLength:function(repeaterObject)
				{
					for(var field in repeaterObject.dataSource.item)						
						return 	repeaterObject.dataSource.item[field].length;		
				},
				
				getItemText:function(repeaterObject)
				{
					if(repeaterObject.dataSource.item==null) return '';
					
					var itemTemplateText='';
					var rowLength=this.private.getRowLength(repeaterObject);						
						for(var iRow=0;iRow<rowLength;iRow++)
						{
							var tempText=repeaterObject.template.item;
							
							for(var field in repeaterObject.dataSource.item)
							{
								var re=new RegExp('\<%#'+field+'%\\>','ig');										
									tempText=tempText.replace(re,repeaterObject.dataSource.item[field][iRow])						
							}
							
							itemTemplateText+=tempText;							
						}		
					return 	itemTemplateText;		
				},
				
				getHeaderText:function(repeaterObject)
				{
					if(repeaterObject.dataSource.header==null) return '';
					
					var headerText=repeaterObject.template.header;
					for(var labelName in repeaterObject.dataSource.header)
					{
						var re=new RegExp('\<%#'+labelName+'%\\>','ig');
						headerText=headerText.replace(re,repeaterObject.dataSource.header[labelName]);
					}
					return headerText;
				},
				
				getFooterText:function(repeaterObject)
				{
					if(repeaterObject.dataSource.footer==null) return '';
					
					var footerText=repeaterObject.template.footer;
					for(var labelName in repeaterObject.dataSource.footer)
					{
						var re=new RegExp('\<%#'+labelName+'%\\>','ig');
						footerText=footerText.replace(re,repeaterObject.dataSource.footer[labelName]);
					}
					return footerText;
				},
				
				getDataobject:function(templateText)
				{
					var tempJson=
					{
						mainTemplate:templateText,
						labels:{},
						repeaters:{}
					};
					
					//处理变量
					var labelEnum=templateText.match(/(\<%=\s*?(\w+)\s*?%\>)/ig);
						if(labelEnum!=null)
						{
							tempJson.labelsCount=labelEnum.length;
							labelEnum=labelEnum.toString().replace(/<%=/g,'')
							labelEnum=labelEnum.toLowerCase().replace(/%\>/g,'')			
							labelEnum=labelEnum.split(',');
							for(var iv=0;iv<labelEnum.length;iv++){
								var tempLabelName=trim(labelEnum[iv]);
								tempJson.labels[tempLabelName]={name:tempLabelName,value:''};
							}
						}
						
					//处理Repeater块
					var repeaterEnum=templateText.match(/<asp:Repeater[^>]*\>[\s\S]*?<\/asp:Repeater\>/ig);
						if(repeaterEnum!=null)
						{
							tempJson.repeatersCount=repeaterEnum.length;
							for(var ir=0;ir<repeaterEnum.length;ir++)
							{
								var rid=strip(repeaterEnum[ir].match(/id="([\s\S]*?)"/i)[1].toLowerCase());
								tempJson.repeaters[rid]={};
								
								tempJson.repeaters[rid].id=rid;
								tempJson.repeaters[rid].template={};
								tempJson.repeaters[rid].dataSource={header:null,item:null,footer:null};
								
								tempJson.repeaters[rid].template.main=repeaterEnum[ir];
								tempJson.repeaters[rid].template.item=regexpMatchValue(repeaterEnum[ir].match(/<itemTemplate[^>]*\>([\s\S]*?)<\/itemTemplate\>/i),1);					
								tempJson.repeaters[rid].template.header=regexpMatchValue(repeaterEnum[ir].match(/<headerTemplate[^>]*\>([\s\S]*?)<\/headerTemplate\>/i),1)||'';
								tempJson.repeaters[rid].template.footer=regexpMatchValue(repeaterEnum[ir].match(/<footerTemplate[^>]*\>([\s\S]*?)<\/footerTemplate\>/i),1)||'';	
							}
						}			
					return tempJson;
				}
			}			
		};	
	};
	
	///<summary>
	///过滤脚本
	///</summary>		
	function stripScripts(str)
	{
		return String(str).replace(new RegExp('<script[^>]*>([\\S\\s]*?)<\/script>','img'),'');
	}
	
	///<summary>
	///过滤HTML标签
	///</summary>	
	function stripTags(str)
	{
		return String(str).replace(/<\/?[^>]+>/gi,'');
	}
	
	///<summary>
	///过滤字符串两边空格
	///</summary>		
	function strip(str)
	{
		return String(str).replace(/^\s+/,'').replace(/\s+$/,'');		
	}
	
	///<summary>
	///过滤不安全的HTML标签
	///</summary>	
	function stripUnsafeHTML(str)
	{
		var result=String(str);
		var unsafeHTML=
		[
			new RegExp('<script[^>]*>([\\S\\s]*?)<\/script>','img'),
			new RegExp('<iframe[^>]*>([\\S\\s]*?)<\/iframe>','img'),
			new RegExp('<object[^>]*>([\\S\\s]*?)<\/object>','img'),
			new RegExp('<link[^>]([\\S\\s]*?)\/>','img')
		];
		//html|body|title|link|meta|
		
		for(var iu=0;iu<unsafeHTML.length;iu++)
		{
			result=result.replace(unsafeHTML[iu],'')
		}
		return result;		
	}
	
	///<summary>
	///过滤字符串左边空格
	///</summary>	
	function leftStrip(str)
	{
		return String(str).replace(/(^[\s]*)/g,'');
	}
	
	///<summary>
	///过滤字符串右边空格
	///</summary>	
	function rightStrip(str)
	{
		return String(str).replace(/([\s]*$)/g,'');
	}
	
	///<summary>
	///从左边截取字串
	///</summary>	
	function leftCutStr(str,len)
	{
		if(isNaN(len)||len==null)
			len = str.length;
		else
			if(parseInt(len)<0||parseInt(len)>this.length) len=str.length;	   
		return str.substr(0,len);			
	}
	
	///<summary>
	///从右边截取字串
	///</summary>		
	function rightCutStr(str,len)
	{
		if(isNaN(len)||len==null)
			len=str.length;
		else
			if(parseInt(len)<0||parseInt(len)>str.length) len=str.length;	   
		return str.substring(str.length-len,str.length);				
	}
	
	///<summary>
	///格式化文本域内的字符串
	///</summary>		
	function formatTextareaStr(str)
	{
		var result=str;
			result=result.replace(/>/g,'&gt;');
			result=result.replace(/</g,'&lt;');					
			result=result.replace(/\n/g,'<br/>');
			result=result.replace(/\t/g,'&nbsp;&nbsp;&nbsp;&nbsp;');
			result=result.replace(/\s/g,'&nbsp;&nbsp;');			
		return result;		
	}
	
	///<summary>
	///对文本进行分页
	///</summary>	
	function textPage()	
	{
	}
	
	///<summary>
	///将数字转化为百分数
	///</summary>		
	function numberToPercent(number,dd)
	{
		return (dd==undefined||isNaN(dd)||Numeric.isInteger(dd)==false) ? ((number*100)+'%') : ((number*100).toFixed(dd)+'%');	
	}
	
	///<summary>
	///去连接ACCESS数据库
	///</summary>	
	function connectionAccessDb(path)
	{
		var conn=Server.CreateObject("ADODB.Connection");
			conn.ConnectionString='Provider=Microsoft.Jet.OLEDB.4.0;Data Source='+path+'';
		return conn;
	}
	
	///<summary>
	///去连接SQLSERVER数据库
	///</summary>		
	function connectionSqlServer(localhost,database,userid,password)
	{
		var conn=Server.CreateObject("ADODB.Connection");
			conn.ConnectionString='server='+localhost+';database='+database+';userid='+userid+';password='+password+';';		
		return conn;
	}
	
	///<summary>
	///计算JSON对象的元素个数
	///</summary>		
	function jsonCount(json)
	{
		var length=0;
		try
		{
			for(var name in json)
				length++;
		}
		catch(e)
		{
			return Number.NaN;
		}
		return length;r
	}
	
	///<summary>
	///请求文件
	///</summary>		
	function include(path,method,data)
	{
		var tempText=null;
		var xmlObject=Server.CreateObject("Microsoft.XMLHTTP");
			xmlObject.Open(method||'GET',path,false);
			xmlObject.send(data||'');
			if(xmlObject.status!=404) 
				tempText=xmlObject.responseText;			
			xmlObject=null;
		return tempText;
	}
	
	///<summary>
	///检测文件是否存在
	///</summary>

	

%>